/**
 * 将十六进制颜色转换为RGB对象
 * @param hex 十六进制颜色值
 * @returns RGB对象
 */
export function hexToRgb(hex: string): { r: number, g: number, b: number } {
  // 移除#前缀如果存在
  hex = hex.replace(/^#/, '');

  // 解析hex值
  let bigint = parseInt(hex, 16);
  let r = (bigint >> 16) & 255;
  let g = (bigint >> 8) & 255;
  let b = bigint & 255;

  return { r, g, b };
}

/**
 * 将RGB对象转换为十六进制颜色
 * @param rgb RGB对象
 * @returns 十六进制颜色值
 */
export function rgbToHex(rgb: { r: number, g: number, b: number }): string {
  return `#${((1 << 24) + (rgb.r << 16) + (rgb.g << 8) + rgb.b).toString(16).slice(1).toUpperCase()}`;
}

/**
 * 提亮颜色
 * @param hex 十六进制颜色值
 * @param level 提亮级别(0-1)
 * @returns 提亮后的十六进制颜色值
 */
export function lighten(hex: string, level: number): string {
  const rgb = hexToRgb(toHexColor(hex));

  // 增加RGB值
  rgb.r = Math.min(255, Math.round(rgb.r + (255 - rgb.r) * level));
  rgb.g = Math.min(255, Math.round(rgb.g + (255 - rgb.g) * level));
  rgb.b = Math.min(255, Math.round(rgb.b + (255 - rgb.b) * level));

  return rgbToHex(rgb);
}

/**
 * 变暗颜色
 * @param hex 十六进制颜色值
 * @param level 变暗级别(0-1)
 * @returns 变暗后的十六进制颜色值
 */
export function darken(hex: string, level: number): string {
  const rgb = hexToRgb(toHexColor(hex));

  // 减少RGB值
  rgb.r = Math.max(0, Math.round(rgb.r * (1 - level)));
  rgb.g = Math.max(0, Math.round(rgb.g * (1 - level)));
  rgb.b = Math.max(0, Math.round(rgb.b * (1 - level)));

  return rgbToHex(rgb);
}


/**
 * 生成颜色变体
 * @param baseColor 基础颜色
 * @param name 颜色名称
 * @returns 颜色变体对象
 */
export function generateColorVariants(baseColor: string, name: string): Record<string, string> {
  const variants: Record<string, string> = {};
  variants[name] = toHexColor(baseColor);

  // 生成light变体 (1-9级)
  for (let i = 1; i <= 9; i++) {
    // 亮度逐渐增加，从0.1到0.9
    variants[`${name}-light-${i}`] = lighten(baseColor, i * 0.1);
  }

  // 生成dark变体 (1-4级)
  for (let i = 1; i <= 4; i++) {
    // 暗度逐渐增加，从0.1到0.4
    variants[`${name}-dark-${i}`] = darken(baseColor, i * 0.1);
  }

  return variants;
}

import { COLOR_NAME_TO_INFO } from './color-names';

/**
 * 将英文颜色名称转换为十六进制色值
 * @param colorName 英文颜色名称
 * @param defaultColor 默认颜色，当找不到对应颜色时返回
 * @returns 十六进制颜色值
 */
export function colorNameToHex(colorName: string, defaultColor: string = '#000000'): string {
  if (!colorName) return defaultColor;

  // 转换为小写并去除空格
  const normalizedName = colorName.toLowerCase().replace(/\s+/g, '');

  // 检查是否已经是十六进制颜色
  if (/^#([0-9a-f]{3}){1,2}$/i.test(normalizedName)) {
    return normalizedName.toUpperCase();
  }

  // 查找颜色映射表
  return COLOR_NAME_TO_INFO[normalizedName]?.hex || defaultColor;
}

/**
 * 检查是否为有效的十六进制颜色
 * @param color 要检查的颜色字符串
 * @returns 是否为十六进制颜色
 */
export function isHexColor(color: string): boolean {
  // 匹配格式: #fff, #ffffff, #FFF, #FFFFFF
  return /^#([0-9a-f]{3}){1,2}$/i.test(color);
}

/**
 * 检查是否为有效的RGB颜色字符串
 * @param color 要检查的颜色字符串
 * @returns 是否为RGB颜色
 */
export function isRgbColor(color: string): boolean {
  // 匹配格式: rgb(255, 0, 0), rgb(0,255,0)
  return /^rgb\(\d{1,3},\d{1,3},\d{1,3}\)$/i.test(color);
}

/**
 * 检查是否为有效的RGBA颜色字符串
 * @param color 要检查的颜色字符串
 * @returns 是否为RGBA颜色
 */
export function isRgbaColor(color: string): boolean {
  // 匹配格式: rgba(255, 0, 0, 0.5), rgba(0,255,0,1)
  return /^rgba\(\d{1,3},\d{1,3},\d{1,3},\d(\.\d+)?\)$/i.test(color);
}

/**
 * 从RGB字符串中提取RGB值
 * @param rgbStr RGB字符串，格式如'rgb(255, 0, 0)'或'rgba(255, 0, 0, 0.5)' 
 * @returns RGB对象，如果格式无效则返回null
 */
function parseRgbString(rgbStr: string): { r: number, g: number, b: number } | null {
  const rgbMatch = rgbStr.match(/^rgba?\((\d{1,3}),(\d{1,3}),(\d{1,3})(?:,(\d(?:\.\d+)?))?\)$/i);
  if (!rgbMatch) return null;

  return {
    r: Math.max(0, Math.min(255, parseInt(rgbMatch[1], 10))),
    g: Math.max(0, Math.min(255, parseInt(rgbMatch[2], 10))),
    b: Math.max(0, Math.min(255, parseInt(rgbMatch[3], 10)))
  };
}

/**
 * 将各种格式的颜色转换为十六进制颜色
 * 支持：十六进制、RGB、RGBA和颜色名称
 * @param color 颜色值，可以是十六进制字符串、RGB字符串、RGBA字符串或颜色名称
 * @returns 十六进制颜色值，如果无法转换则返回默认黑色
 */
export function toHexColor(color: string): string {
  if (!color) return '#000000';

  // 检查是否已经是十六进制颜色
  if (isHexColor(color)) {
    return color.toUpperCase();
  }

  // 检查是否是RGB颜色
  if (isRgbColor(color) || isRgbaColor(color)) {
    const rgb = parseRgbString(color);
    if (rgb) {
      return rgbToHex(rgb);
    }
  }

  // 检查是否是颜色名称
  const hexFromName = colorNameToHex(color);
  if (hexFromName !== '#000000' || color.toLowerCase() === 'black') {
    return hexFromName;
  }

  // 如果以上都不是，返回默认黑色
  return '#000000';
}

/**
 * 基于亮色模式颜色计算暗黑模式颜色
 * 实现逻辑：根据颜色亮度实现深浅反转，亮色调转暗色调，暗色调转亮色调
 * 特殊处理：黑色(#000000)转为白色(#FFFFFF)，白色(#FFFFFF)转为黑色(#000000)
 * @param lightColor 亮色模式颜色，可以是十六进制、RGB、RGBA或颜色名称
 * @returns 暗黑模式颜色（十六进制格式）
 */
export function calculateDarkColor(lightColor: string): string {
  // 首先检查是否是颜色名称，如果是则转换为十六进制
  const hexColor = toHexColor(lightColor);

  // 特殊颜色处理
  if (hexColor === '#000000') return '#FFFFFF';
  if (hexColor === '#FFFFFF') return '#000000';

  // 将hex颜色转换为RGB
  const rgbMatch = hexColor.match(/^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i);
  if (!rgbMatch) return lightColor;

  const r = parseInt(rgbMatch[1], 16);
  const g = parseInt(rgbMatch[2], 16);
  const b = parseInt(rgbMatch[3], 16);

  // 计算当前颜色亮度 (luminance)，使用标准加权公式
  // 人眼对绿色最敏感，红色次之，蓝色最不敏感
  const currentLuminance = 0.299 * r + 0.587 * g + 0.114 * b;

  // 设置默认反转强度系数 (0-1)
  // 0.85表示不完全反转，保留一些原始颜色特性
  const inversionIntensity = 0.85;

  // 计算目标亮度 (255 - currentLuminance) 并应用反转强度
  const targetLuminance = (255 - currentLuminance) * inversionIntensity;

  // 计算亮度差
  const luminanceDiff = targetLuminance - currentLuminance;

  // 调整RGB值，应用相同的亮度差
  let newR = Math.round(r + luminanceDiff);
  let newG = Math.round(g + luminanceDiff);
  let newB = Math.round(b + luminanceDiff);

  // 确保RGB值在0-255范围内
  newR = Math.max(0, Math.min(255, newR));
  newG = Math.max(0, Math.min(255, newG));
  newB = Math.max(0, Math.min(255, newB));

  // 转换回hex格式
  return `#${((1 << 24) + (newR << 16) + (newG << 8) + newB).toString(16).slice(1).toUpperCase()}`;
}